import { defineStore } from 'pinia'
import { ArticleService } from '@/api/services/articleService'
import type { ArticleVO } from '@/types/article'
import zm from '@/utils/zm'

/**
 * 编辑器专用Store
 * 职责：管理文章编辑、草稿保存、发布等功能
 */
export const useEditorStore = defineStore('editor', {
  state() {
    return {
      // 编辑中的当前文章
      currentArticle: {
        id: '',
        title: '',
        content: '',
        cover: '',
        typeId: null,
        status: 0, // 0: 草稿, 1: 已发布
      } as Partial<ArticleVO>,
      
      // 编辑器状态
      editorMode: 'create' as 'create' | 'edit', // 创建模式 or 编辑模式
      isAutoSaving: false, // 是否正在自动保存
      isDirty: false, // 内容是否有变化
      lastSaveTime: null as Date | null, // 上次保存时间
      typeOptions:[ { label: "技术", value: 1 },
                    { label: "生活", value: 2 },
                    { label: "随笔", value: 3 },
                    { label: "教程", value: 4 },
                    { label: "分享", value: 5 }],//文章类型数组

      //========当前页面能编辑的属性========
      editorHtml: '', // HTML内容
      editorText: '', // 纯文本内容
      // 发布预设置
      publishSettings: {
        cover: '',
        typeId: null as number | null,
        tags: [] as string[],
      },
      
      // 自动保存设置
      autoSaveEnabled: true // 是否启用自动保存
    }
  },

  actions: {
    /**
     * 初始化编辑器（创建新文章）
     */
    initCreateMode() {
      this.editorMode = 'create'
      this.currentArticle = {
        id: '',
        title: '',
        content: '',
        cover: '',
        typeId: null,
        status: 0,
      }
      this.editorHtml = ''
      this.publishSettings = {
        cover: '',
        typeId: null,
        tags: [],
      }
      this.isDirty = false
    },

    /**
     * 初始化编辑器（编辑现有文章）
     */
    async initEditMode(articleId: string) {
      this.editorMode = 'edit'
      try {
        const res = await ArticleService.getArticleForEdit(articleId)
        if (zm.isNotNon(res)) {
          this.currentArticle = res
          this.editorHtml = res.content || ''
          // 修复类型错误：明确指定 typeId 的类型
          const typeId: number | null = res.typeId !== undefined ? res.typeId : null
          this.publishSettings = {
            cover: res.cover || '',
            typeId: typeId,
            tags: []
          }
          this.isDirty = false
        }
      } catch (error) {
        zm.error('获取文章内容失败')
        console.error('Edit mode init error:', error)
      }
    },

    /**
     * 更新文章标题
     */
    updateTitle(title: string) {
      this.currentArticle.title = title
      this.markDirty()
    },

    /**
     * 更新编辑器内容
     */
    updateContent(html: string, text: string) {
      this.editorHtml = html
      this.editorText = text
      this.currentArticle.content = html
      this.markDirty()
    },

    /**
     * 更新发布设置
     */
    updatePublishSettings(settings: Partial<typeof this.publishSettings>) {
      this.publishSettings = { ...this.publishSettings, ...settings }
      this.markDirty()
    },

    /**
     * 标记内容已修改
     */
    markDirty() {
      this.isDirty = true
    },

    /**
     * 自动保存草稿（调用统一的保存方法）
     */
    async autoSaveDraft() {
      // 只有启用自动保存时才执行
      if (this.autoSaveEnabled) {
        await this.saveDraft(true)
      }
    },

    /**
     * 保存草稿
     * @param isAuto 是否为自动保存，默认为 false
     */
    async saveDraft(isAuto: boolean = false) {
      // 自动保存时的特殊检查
      if (isAuto && (!this.isDirty || this.isAutoSaving)) return

      // 如果是自动保存，设置状态标识
      if (isAuto) {
        this.isAutoSaving = true
      }

      try {
        //参数合并
        const articleData = {
          // 从当前文章继承基础属性
          ...this.currentArticle,
          // 使用编辑器中的最新内容
          content: this.editorText,
          html:this.editorHtml,
          // 使用发布设置中的最新值
          cover: this.publishSettings.cover,
          typeId: this.publishSettings.typeId,
          // 设置为草稿状态
          status: 0
        }
        console.log(articleData);
        
        const res = await ArticleService.saveDraft(articleData)
        if (res?.id) {
          if (this.editorMode === 'create' && res.id) {
            this.currentArticle.id = res.id
            this.editorMode = 'edit'
          }
          this.isDirty = false
          this.lastSaveTime = new Date()
          
          // 根据保存类型提供不同的用户反馈
          if (isAuto) {
            console.log('草稿自动保存成功')
          } else {
            zm.success('草稿保存成功')
          }
        }
        return res
      } catch (error) {
        // 根据保存类型提供不同的错误处理
        if (isAuto) {
          console.error('自动保存失败:', error)
        } else {
          zm.error('草稿保存失败')
          console.error('Save draft error:', error)
        }
      } finally {
        // 如果是自动保存，重置状态标识
        if (isAuto) {
          this.isAutoSaving = false
        }
      }
    },

    /**
     * 发布文章
     */
    async publishArticle() {
      if (!this.currentArticle.title?.trim()) {
        zm.warning('请输入文章标题')
        return false
      }

      if (!this.editorHtml?.trim()) {
        zm.warning('请输入文章内容')
        return false
      }

      // 发布文章时校验文章类型和封面图
      if (!this.publishSettings.typeId) {
        zm.warning('请选择文章类型')
        return false
      }

      if (!this.publishSettings.cover) {
        zm.warning('请上传文章封面图')
        return false
      }

      try {
        //合并参数
        const articleData = {
          ...this.currentArticle,
          // 使用编辑器中的最新内容
          content: this.editorText,
          html:this.editorHtml,
          cover: this.publishSettings.cover,
          typeId: this.publishSettings.typeId,
          // 设置为已发布状态
          status: 1
        }
        
        const code = await ArticleService.publishArticle(articleData)
        console.log(code);
        
        if (code==200) {
          this.isDirty = false
          zm.success('文章发布成功！')
          return true
        }
          return false
      } catch (error) {
        zm.error('文章发布失败')
        console.error('Publish error:', error)
        return false
      }
    },


    /**
     * 预览文章
     */
    getPreviewData() {
      return {
        title: this.currentArticle.title || '无标题',
        content: this.editorHtml,
        cover: this.publishSettings.cover,
      }
    },
    
    /**
     * 更新自动保存设置
     */
    updateAutoSaveSettings(enabled: boolean) {
      this.autoSaveEnabled = enabled
    }
  },

  getters: {
    /**
     * 是否可以发布
     */
    canPublish(): boolean {
      return !!(this.currentArticle.title?.trim() && this.editorHtml?.trim())
    },

    /**
     * 字数统计
     */
    wordCount(): number {
      return this.editorText?.length || 0
    },

    /**
     * 上次保存时间格式化
     */
    lastSaveTimeFormatted(): string {
      if (!this.lastSaveTime) return '未保存'
      const now = new Date()
      const diff = now.getTime() - this.lastSaveTime.getTime()
      const minutes = Math.floor(diff / 60000)
      
      if (minutes < 1) return '刚刚保存'
      if (minutes < 60) return `${minutes}分钟前保存`
      const hours = Math.floor(minutes / 60)
      if (hours < 24) return `${hours}小时前保存`
      return this.lastSaveTime.toLocaleDateString()
    }
  }
})